package com.OrderingSystem.controller.seller;

import cn.hutool.core.date.DateUtil;
import com.OrderingSystem.pojo.Loginlog;
import com.OrderingSystem.pojo.User;
import com.OrderingSystem.service.ILoginlogService;
import com.OrderingSystem.service.UserService;
import com.OrderingSystem.utils.Iputil;
import com.OrderingSystem.utils.Result;
import com.OrderingSystem.utils.TokenUtil;
import com.OrderingSystem.utils.UserForm;
import lombok.extern.slf4j.Slf4j;
import org.jasypt.encryption.StringEncryptor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import java.util.HashMap;
import java.util.Map;

/**
 * 用户控制器
 * 处理用户相关的HTTP请求，如登录、注册、获取用户信息等
 */
@Slf4j
@RestController
@RequestMapping("/user")
public class UserController {

    // 注入用户服务
    @Autowired
    private UserService userService;

    // 注入Token工具类
    @Autowired
    private TokenUtil tokenUtil;

    // 注入Jasypt字符串加密器
    // 这个加密器是在JasyptConfig中配置的Bean
    @Qualifier("jasyptStringEncryptor")
    @Autowired
    private StringEncryptor encryptor;

    @Resource
    ILoginlogService loginlogService;

    @Autowired
    StringRedisTemplate stringRedisTemplate;

    /**
     * 用户登录接口
     * @param user 包含用户名和密码的用户对象
     * @return 登录结果，包含用户信息和Token
     */
    @PostMapping("/login")
    public Result login(@RequestBody User user) {

        // 调用服务层的登录方法
        User loginUser = userService.findByUsername(user.getUsername());
        if (loginUser != null) {
            String decrypt = encryptor.decrypt(loginUser.getPassword());
            if(user.getPassword().equals(decrypt)){

                Loginlog loginlog=new Loginlog();
                loginlog.setLogintime(DateUtil.parseLocalDateTime(DateUtil.now()));
                loginlog.setName(loginUser.getUsername());

                String ip = Iputil.getIp();
                loginlog.setIp(ip); //登录IP地址
                loginlog.setAddress(Iputil.getAddress(ip));
                //新增改对象到数据库
                loginlogService.save(loginlog);

                // 登录成功，生成Token
                String token = tokenUtil.generateToken(loginUser.getUsername());
                // 准备返回数据，包含用户信息和Token
                Map<String, Object> data = new HashMap<>();
                // 出于安全考虑，清除密码信息
                loginUser.setPassword(null);
                data.put("user", loginUser);
                data.put("token", token);
                return Result.success(data);
            } else {
                // 登录失败，返回错误信息
                return Result.error("用户名或密码错误");
            }
        } else {
            // 登录失败，返回错误信息
            return Result.error("用户名或密码错误");
        }
    }

    /**
     * 用户注册接口
     * @param user 包含注册信息的用户对象
     * @return 注册结果
     */
    @PostMapping("/register")
    public Result register(@RequestBody User user) {
        // 简单验证用户名和密码是否为空
        if (user.getUsername() == null || user.getUsername().isEmpty() ||
                user.getPassword() == null || user.getPassword().isEmpty()) {
            return Result.error("用户名和密码不能为空");
        }
        // 调用服务层的注册方法
        boolean success = userService.register(user);
        if (success) {
            return Result.success("注册成功");
        } else {
            return Result.error("用户名已存在");
        }
    }

    /**
     * 获取当前登录用户信息接口
     * 此接口受权限拦截器保护，需要登录后才能访问
     *
     * @param request HTTP请求对象，用于获取Token
     * @return 当前登录用户的信息
     */
    @PostMapping("/info")
    public Result getUserInfo(HttpServletRequest request) {
        // 从请求头中获取Token
        String token = request.getHeader("token");

        // 从Token中获取用户名
        String username = tokenUtil.getUsernameFromToken(token);

        // 查询用户信息
        User user = userService.findByUsername(username);

        // 出于安全考虑，清除密码信息
        if (user != null) {
            user.setPassword(null);
        }
        return Result.success(user);
    }


    @PostMapping("/updatepwd")
    public Result updatepwd(@RequestBody UserForm userForm, HttpServletRequest request) {
        // 从请求头中获取Token
        String token = request.getHeader("token");
        // 从Token中获取用户名
        String username = tokenUtil.getUsernameFromToken(token);
        // 查询用户信息
        User user = userService.findByUsername(username);
        String decrypt = encryptor.decrypt(user.getPassword());
        if(decrypt.equals(userForm.getPassword())){
            if(decrypt.equals(userForm.getPassword1())){
                return Result.error("新密码不能和原密码一致");
            }else{
                if(userForm.getPassword1().equals(userForm.getPassword2())){
                    user.setPassword(encryptor.encrypt(userForm.getPassword1()));
                    boolean b = userService.updateById(user);
                    if(b){
                        return Result.success();
                    }else {
                        return Result.error("密码修改异常");
                    }
                }else{
                    return Result.error("新密码两次输入不一致");
                }
            }
        }else {
            return Result.error("原密码不正确");
        }
    }
}
    